1. Field of the Invention
The invention relates generally to the testing of microprocessors and more particularly to the use of self-modifying code for testing the addressing modes which are available in a microprocessor.
2. Description of the Relevant Art
As a result of the increasing speed and complexity of integrated circuits (ICs), these devices can incorporate more and more functions. As a result, it is becoming increasingly difficult and time consuming to test and debug the design and operation of these products. (Debugging is the process of finding and eliminating problems, or bugs, in hardware or software.)
When a new IC design is implemented, it must be debugged and tested to ensure that each feature of the device functions as expected. The complexity of debugging and testing has grown commensurately with the complexity of the devices themselves. The increased costs and time to debug and test can cause delays which disrupt manufacturing flows and hinder manufacturers"" efforts to bring the products to market.
A microprocessor is one type of device which presents a complex testing environment. A great deal of the time required to develop and implement a new microprocessor design is spent on debugging the design. Because debugging has an enormous impact on the development cycle of new microprocessors, faster and more powerful debugging tools have had to be developed. These tools include both features internal to the microprocessor which facilitate debugging, and external tools such as logic analyzers and debug/test software.
Microprocessor debug and test systems in the prior art are typically implemented using a computer system such as a personal computer (PC). The PC is coupled to interface hardware, which is in turn coupled to the microprocessor. Software tools are executed on the PC to provide debug/test functionality. Because of the complexity of microprocessors and their functions, software debug/test tools must also be very complex. Individual tests must be conducted on the microprocessor to ensure that each of the functions of the device is properly performed.
The testing of a microprocessor may be made more complicated by the fact that the device may provide more than one way to perform a given function. For example, a microprocessor requires address information in order to perform an operation such as a load, but the address may be specified in a number of different ways. The address may be given in the form of an immediate value, an offset from a base value, a pointer (which points to a value), or in various other forms. The debug/test application must be programmed to test each of the addressing modes to ensure that the design functions properly.
Debug/test software in the prior art uses in-line code to test the addressing modes of a microprocessor. Sections of code are included to test each addressing mode and each section of code is consecutively executed when the microprocessor is tested. Because of the large number of addressing modes which may be provided by the microprocessor, amount of code devoted simply to testing the addressing modes can be very large. The large amount of code which is necessary to test all of the possible addressing modes is time consuming to write, it is tedious and can therefore be prone to errors, it can be difficult to debug and maintain, and it takes up large amounts of storage space.
One or more of the problems outlined above may be solved by the method of the present invention. The invention uses self-modifying code to testing available addressing modes. The use of self-modifying code may result in executable files which are smaller and may run faster than code written using prior art methods. The inventive method may also reduce the amount of work required to write, maintain and update the test code.
Test code is written to verify the operation of a single addressing mode. The test code is written in a format which employs numeric opcodes rather than instruction mnemonics. Following the test code in program order is code written to increment the addressing mode. After the addressing mode is incremented, the program then loops back to the beginning of the test code and the next addressing mode is tested.
The program includes self-modifying code. That is, a portion of the test code is overwritten by the program on successive iterations of a test loop. The test loop is modified in a controlled manner to cause different addressing modes to be tested. The modification of the code is accomplished by mirroring the code segment of the program with a data segment (i.e., the two segments are mapped to the same location in memory). By mirroring the code and data segments, changes to the data are, in effect, changes to the code. The program increments the addressing mode and then stores addressing mode data in locations occupied by the portions of the test code corresponding to the previous addressing mode. The program thereby updates the test code to allow verification of subsequent addressing modes.